package com.quanyan.place.task;

import com.github.ltsopensource.core.domain.Job;
import com.github.ltsopensource.jobclient.JobClient;
import com.github.ltsopensource.jobclient.domain.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author xian-guo
 */

public class TimerTaskJob {
    private static final Logger LOGGER = LoggerFactory.getLogger(TimerTaskJob.class);
    @Autowired
    private JobClient jobClient;

    public void executeTask(){
        /**
         * yaoxin.liu job
         */
        Job updateStatusJob = new Job();
        updateStatusJob.setTaskId("placePeriodSeaArea");//每个任务必须指定唯一
        updateStatusJob.setParam("type", "placePeriodSeaArea");//执行多个任务，传递参数
        updateStatusJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        updateStatusJob.setNeedFeedback(true);
        updateStatusJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateStatusJob.setCronExpression("0 0 1 * * ?");
        Response updateStatusJobResp = jobClient.submitJob(updateStatusJob);
        LOGGER.info("-------------------------场馆周期管理任务开始执行>>>>>>>>>>>>>>>>>" + updateStatusJobResp);

        /*Job financeJob = new Job();
        financeJob.setTaskId("task_Place_finance");//每个任务必须指定唯一
        financeJob.setParam("type", "placeFinanceData");//执行多个任务，传递参数
        financeJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        financeJob.setNeedFeedback(true);
        financeJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        financeJob.setCronExpression("0 0 2 * * ?");
        Response financeJobResp = jobClient.submitJob(financeJob);
        LOGGER.info("------------------------财务报表定时任务执行>>>>>>>>>>>>>>>>>" + financeJobResp);*/

        Job contractJob = new Job();
        contractJob.setTaskId("contract_Place_finance");//每个任务必须指定唯一
        contractJob.setParam("type", "contractPlaceData");//执行多个任务，传递参数
        contractJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        contractJob.setNeedFeedback(true);
        contractJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        contractJob.setCronExpression("0 0 3 * * ?");
        Response contractJobResp = jobClient.submitJob(contractJob);
        LOGGER.info("-------------------------合同列表定时任务执行>>>>>>>>>>>>>>>>>" + contractJobResp);


        /**
         * jingxiong.chen job
         */
        Job orderCompleteJob = new Job();
        orderCompleteJob.setTaskId("orderCompleteStatusCheckTask");//每个任务必须指定唯一
        orderCompleteJob.setParam("type", "orderCompleteStatusCheckTask");//执行多个任务，传递参数
        orderCompleteJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        orderCompleteJob.setNeedFeedback(true);
        orderCompleteJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        orderCompleteJob.setCronExpression("0 10 0/1 * * ?");
        Response orderCompleteResp = jobClient.submitJob(orderCompleteJob);
        LOGGER.info("-------------------------订单交易完成检查任务开始执行>>>>>>>>>>>>>>>>>" + orderCompleteResp);

        Job updateBlockBookingStatusJob = new Job();
        updateBlockBookingStatusJob.setTaskId("updateBlockBookingStatus");//每个任务必须指定唯一
        updateBlockBookingStatusJob.setParam("type", "updateBlockBookingStatus");//执行多个任务，传递参数
        updateBlockBookingStatusJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        updateBlockBookingStatusJob.setNeedFeedback(true);
        updateBlockBookingStatusJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        updateBlockBookingStatusJob.setCronExpression("0 30 1 * * ?");
        Response updateBlockBookingStatusResp = jobClient.submitJob(updateBlockBookingStatusJob);
        LOGGER.info("-------------------------当前时间一周内的包场订单设置为可用状态任务开始执行>>>>>>>>>>>>>>>>>" + updateBlockBookingStatusResp);


        /**
         * yun.yang job
         */

        Job syncPlaceSalePlanJob = new Job();
        syncPlaceSalePlanJob.setTaskId("syncPlaceSalePlan");//每个任务必须指定唯一
        syncPlaceSalePlanJob.setParam("type", "syncPlaceSalePlan");//执行多个任务，传递参数
        syncPlaceSalePlanJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        syncPlaceSalePlanJob.setNeedFeedback(true);
        syncPlaceSalePlanJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        syncPlaceSalePlanJob.setCronExpression("0 0 23 * * ?");
        Response syncPlaceSalePlanResp = jobClient.submitJob(syncPlaceSalePlanJob);
        LOGGER.info("-------------------------定时同步销售计划任务开始执行>>>>>>>>>>>>>>>>>" + syncPlaceSalePlanResp);

        /**
         * jing.liu job
         */
        Job updatePlaceIndexJob = new Job();
        updatePlaceIndexJob.setTaskId("updatePlaceIndex");//每个任务必须指定唯一
        updatePlaceIndexJob.setParam("type", "updatePlaceIndex");//执行多个任务，传递参数
        updatePlaceIndexJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        updatePlaceIndexJob.setNeedFeedback(true);
        updatePlaceIndexJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        updatePlaceIndexJob.setCronExpression("0 0 0 * * ?");
        Response updatePlaceIndexResp = jobClient.submitJob(updatePlaceIndexJob);
        LOGGER.info("-------------------------更新场馆索引任务开始执行>>>>>>>>>>>>>>>>>" + updatePlaceIndexResp);

        /**
         *  场馆价格修改后，每10分钟统一同步到solr服务器
         */
        Job syncPlaceInfoToSolrJob = new Job();
        syncPlaceInfoToSolrJob.setTaskId("task_orderPay_close_order");//每个任务必须指定唯一
        syncPlaceInfoToSolrJob.setParam("type","syncPlaceInfoToSolr");//执行多个任务，传递参数
        syncPlaceInfoToSolrJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        syncPlaceInfoToSolrJob.setNeedFeedback(true);
        syncPlaceInfoToSolrJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        /*syncPlaceInfoToSolrJob.setRepeatCount(-1);             // 无限循环
        syncPlaceInfoToSolrJob.setRepeatInterval(1 * 60 * 1000L);*/
        syncPlaceInfoToSolrJob.setCronExpression("0 0/10 * * * ?");
        Response syncPlaceInfoToSolrJobResp = jobClient.submitJob(syncPlaceInfoToSolrJob);
        LOGGER.info("-------------------------每10分钟同步到solr服务器任务开始执行>>>>>>>>>>>>>>>>>" + syncPlaceInfoToSolrJobResp);


        Job promoteAccountJob = new Job();
        promoteAccountJob.setTaskId("task_place_promote_account");//每个任务必须指定唯一
        promoteAccountJob.setParam("type","placePromoteAccount");//执行多个任务，传递参数
        promoteAccountJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        promoteAccountJob.setNeedFeedback(true);
        promoteAccountJob.setReplaceOnExist(false);             // 当任务队列中存在这个任务的时候，是否替换更新
        promoteAccountJob.setRepeatCount(-1);                   // 无限循环
        promoteAccountJob.setCronExpression("0 15 0/1 * * ?");
        Response promoteSettleJobResp = jobClient.submitJob(promoteAccountJob);
        LOGGER.info("-------------------------场馆短信推广奖励结算开始执行>>>>>>>>>>>>>>>>>" + promoteSettleJobResp);



        /**


         * 自营场馆现金订单结算
         */
        Job placeCashOrderAccountJob = new Job();
        placeCashOrderAccountJob.setTaskId("task_place_cash_order_account");//每个任务必须指定唯一
        placeCashOrderAccountJob.setParam("type","placeCashOrderAccountTask");//执行多个任务，传递参数
        placeCashOrderAccountJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        placeCashOrderAccountJob.setNeedFeedback(true);
        placeCashOrderAccountJob.setReplaceOnExist(false);             // 当任务队列中存在这个任务的时候，是否替换更新
        placeCashOrderAccountJob.setRepeatCount(-1);                   // 无限循环
        placeCashOrderAccountJob.setCronExpression("0 0 2 * * ?");
        //placeCashOrderAccountJob.setRepeatInterval(30*60*1000L);
        Response placeCashOrderAccountResp = jobClient.submitJob(placeCashOrderAccountJob);
        LOGGER.info("-------------------------自营场馆现金订单结算开始执行>>>>>>>>>>>>>>>>>" + placeCashOrderAccountResp);

		/**

         * 第三方场馆订单结算
         */
        Job placePoolOrderAccountJob = new Job();
        placePoolOrderAccountJob.setTaskId("task_place_pool_order_account");//每个任务必须指定唯一
        placePoolOrderAccountJob.setParam("type","placePoolOrderAccount");//执行多个任务，传递参数
        placePoolOrderAccountJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        placePoolOrderAccountJob.setNeedFeedback(true);
        placePoolOrderAccountJob.setReplaceOnExist(false);             // 当任务队列中存在这个任务的时候，是否替换更新
        placePoolOrderAccountJob.setRepeatCount(-1);                   // 无限循环
        placePoolOrderAccountJob.setCronExpression("0 0 1 * * ?");
        Response placePoolOrderAccountJobResp = jobClient.submitJob(placePoolOrderAccountJob);
        LOGGER.info("-------------------------第三方场馆订单结算开始执行>>>>>>>>>>>>>>>>>" + placePoolOrderAccountJobResp);


        /**
         *  场馆推广佣金月结,每个月开始结算上一个月的佣金
         */
        Job promoteRewardJob = new Job();
        promoteRewardJob.setTaskId("task_place_promote_reward");//每个任务必须指定唯一
        promoteRewardJob.setParam("type","placePromoteRewardSettleTask");//执行多个任务，传递参数
        promoteRewardJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        promoteRewardJob.setNeedFeedback(true);
        promoteRewardJob.setReplaceOnExist(false);             // 当任务队列中存在这个任务的时候，是否替换更新
        promoteRewardJob.setRepeatCount(-1);                   // 无限循环
        promoteRewardJob.setCronExpression("0 5 3 1 * ?");     // 每月1号凌晨3点5分0秒执行
        Response promoteRewardSettleJobResp = jobClient.submitJob(promoteRewardJob);
        LOGGER.info("-------------------------场馆短信推广奖励结算开始执行>>>>>>>>>>>>>>>>>" + promoteRewardSettleJobResp);

        /**
         * 每天凌晨3点更新 场馆是否有精彩活动
         */
        Job placeWonderfulActivityJob = new Job();
        placeWonderfulActivityJob.setTaskId("place_wonderful_activity");//每个任务必须指定唯一
        placeWonderfulActivityJob.setParam("type", "placeWonderfulActivity");//执行多个任务，传递参数
        placeWonderfulActivityJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        placeWonderfulActivityJob.setNeedFeedback(true);
        placeWonderfulActivityJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        placeWonderfulActivityJob.setCronExpression("0 0 3 * * ?");
        Response placeWonderfulActivityResp = jobClient.submitJob(placeWonderfulActivityJob);
        LOGGER.info("------------------------- 更新场馆精彩活动任务开始执行>>>>>>>>>>>>>>>>>" + placeWonderfulActivityResp);


        /**
         * youxiaojia job
         * 更新已付款购物车订单为完成状态  每天凌晨0点执行
         */
        Job completeShoppingCartJob = new Job();
        completeShoppingCartJob.setTaskId("shoppingCartOrderCheckTask");//每个任务必须指定唯一
        completeShoppingCartJob.setParam("type", "shoppingCartOrderCheckTask");//执行多个任务，传递参数
        completeShoppingCartJob.setTaskTrackerNodeGroup("taskTracker_place");//每个模块指定不同的名称，但同一个模块不同任务必须相同
        completeShoppingCartJob.setNeedFeedback(true);
        completeShoppingCartJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        completeShoppingCartJob.setCronExpression("0 0 0 * * ?");
        Response completeShoppingCartJobResp = jobClient.submitJob(completeShoppingCartJob);
        LOGGER.info("-------------------------定时更新购物车订单状态任务开始执行>>>>>>>>>>>>>>>>>" + completeShoppingCartJobResp);
    }

}
